\part{Descrizione del codice}

\frame{
    \transboxout
    \partpage 
}

\section{\texttt{Heat-Spectral}}

\subsection{La libreria}


\frame{
        \frametitle{La libreria \texttt{Heat-Spectral}}
	\begin{alertblock}{La libreria \texttt{Heat-Spectral}}
	\begin{itemize}
		\item Risolve problemi parabolici bidimensionali, su griglie strutturate cartesiane, attraverso il metodo spettrale SEM-NI.
	\end{itemize}
	\end{alertblock}
	\begin{block}{Principali sviluppi rispetto al codice pre-esistente:}
	\begin{itemize}
	        \item estrazione del solutore ellittico monodominio;
	        \item implementazione delle condizioni di tipo Neumann non omogenee;
	        \item estensione al caso di problemi parabolici;
	        \item implementazione di un'interfaccia grafica, attraverso la generazione di opportuni script.
	\end{itemize}
	\end{block}
}


\subsection{I software esterni}


\frame{
        \frametitle{Software esterni}
	Per la realizzazione della libreria ci siamo avvalsi del supporto di software esterni:
	\begin{itemize}
		\item il sistema di controllo di versione \texttt{subversion};
		\item la libreria per matrici sparse \texttt{UMFPACK};
		\item il programma di visualizzazione grafica \texttt{gnuplot};
		\item l'encoder video \texttt{MEncoder};
		\item il generatore automatico di documentazione \texttt{doxygen}.
	\end{itemize}
}


\section{Le classi principali}

\subsection{Le classi di base}


\frame{
        \frametitle{Le classi di base}
	La classe \texttt{Problem} è il nucleo del codice. Chiama le altre classi che svolgono le principali operazioni.
	\begin{block}{Altre classi}
	\begin{itemize}
		\item \texttt{Point}: definisce il punto nel piano cartesiano;
		\item \texttt{Poly}: permette di rappresentare i polinomi;
		\item \texttt{TensorProd}: definisce il prodotto tensoriale tra due polinomi monodimensionali;
		\item \texttt{Integrator}: implementa le formule di integrazione gaussiana sui nodi GLL;
	\end{itemize}
	\end{block}
}


\frame{
        \frametitle{Le classi di base}
	\begin{block}{Altre classi}
	\begin{itemize}
		\item \texttt{Map2d}: implementa la trasformazione tra l'elemento di riferimento e un qualsiasi elemento rettangolare assegnato;
		\item \texttt{Functor}: permette di valutare una funzione su uno specifico elemento;
		\item \texttt{Product}: permette di effettuare il prodotto tra due funzioni.
	\end{itemize}
	\end{block}
}
	

\subsection{La classe Mesh}


\frame{
        \frametitle{La classe \texttt{Mesh}}
	\begin{alertblock}{La classe \texttt{Mesh}}
	\begin{itemize}
		\item permette di memorizzare la griglia di calcolo bidimensionale su un dominio rettangolare per il metodo SEM-NI;
		\item fornisce i principali strumenti di calcolo utilizzabili nella fase della costruzione del problema da parte dell'utente.
	\end{itemize}
	\end{alertblock}
	\begin{block}{Principali attributi privati:}
	\begin{description}[\texttt{int \_nnodes}:]
	        \item[\texttt{int \_nx}:] numero di elementi sull'asse x;
        	\item[\texttt{int \_ny}:] numero di elementi sull'asse y;
        	\item[\texttt{int \_nnodes}:] numero di nodi utilizzati dalla formula di quadratura GLL;
	\end{description}
	\end{block}
}


\frame{
        \frametitle{La classe \texttt{Mesh}}
	\begin{block}{Principali attributi privati:}
	\begin{description}[\texttt{Point$<$double$>$ \_A}:]
        	\item[\texttt{Point$<$double$>$ \_A}:] punto del dominio in basso a sinistra;
        	\item[\texttt{Point$<$double$>$ \_B}:] punto del dominio in alto a destra;
        	\item[\texttt{double \_legDelta}:] minimo incremento nella formula di Newton utilizzata per ottenere i nodi GLL;
        	\item[\texttt{double \_legEps}:] residuo critico nella formula di Newton utilizzata per ottenere i nodi GLL;
        	\item[\texttt{double *\_vertexX}:] nodi dell'asse x;
        	\item[\texttt{double *\_vertexY}:] nodi dell'asse y.
	\end{description}
	\end{block}
}


\frame{
        \frametitle{La classe \texttt{Mesh}}
	\begin{block}{I metodi principali si occupano di ritornare:}
	\begin{itemize}
        	\item la numerazione dei nodi e degli elementi;
        	\item le coordinate dei nodi;
	        \item la restrizione di una certa funzione o di un vettore su un elemento assegnato;
        	\item la traccia al bordo di una funzione;
        	\item la base lagrangiana;
	\end{itemize}
	\end{block}
	\begin{block}{Altri metodi permettono di:}
	\begin{itemize}
        	\item interpolare una funzione $f$ sulla mesh;
        	\item ricavare le derivate spaziali di oggetti di tipo \texttt{TensorProd} oppure \texttt{Solution};
        	\item calcolare il prodotto scalare $L^2$ tra funzioni;
		\item salvare in un file di testo i valori di un vettore.
	\end{itemize}
	\end{block}
}


\subsection{La classe UMFMatrix}

\frame{
	\frametitle{La classe \texttt{UMFMatrix}}
	\begin{alertblock}{Obiettivo e modalità di funzionamento}
		\begin{itemize}
			\item Interagisce con la libreria \texttt{UMFPACK} allo scopo di fattorizzare le matrici e risolvere sistemi lineari.
			\item Permette di memorizzare le matrici in formato sparso \texttt{CSC}, costruendo, al posto di un'intera matrice, soltanto tre vettori.
		\end{itemize}
	\end{alertblock}\pause
	
	\begin{block}{I vettori di \texttt{UMFMatrix}}
		\begin{itemize}
        			\item Il vettore \texttt{\_Ax} dei valori non-nulli nella matrice;
		        	\item Il vettore \texttt{\_Ap} degli indici del primo elemento di ogni colonna;
		        	\item Il vettore \texttt{\_Ai} degli indici della posizione verticale di ogni elemento.
		\end{itemize}
	\end{block}
}

\frame{
        \frametitle{La classe \texttt{UMFMatrix}}
	\begin{block}{I suoi metodi principali sono:}
	\begin{description}
		\item[\texttt{multiply}:] permette di moltiplicare una matrice per un vettore;
		\item[\texttt{factorize}:] è in grado di fattorizzare la matrice sfruttando i metodi di \texttt{UMFPACK};
		\item[\texttt{solve}:] risolve il sistema lineare, sempre utilizzando gli algoritmi di \texttt{UMFPACK}.
	\end{description}
	\end{block}
}

\subsection{La classe Problem}

\frame{
	\frametitle{La classe \texttt{Problem}}
	\begin{alertblock}{Obiettivo e modalità di funzionamento}
		\begin{itemize}
			\item Permette all'utente di definire e risolvere il problema evolutivo.
			\item Utilizza le strutture di \texttt{mesh} e gli algoritmi di \texttt{UMFMatrix}.
		\end{itemize}
	\end{alertblock}\pause
	
	\begin{block}{I suoi metodi principali sono:}
		\begin{description}
			\item[\texttt{initialize}:] genera il problema evolutivo e costruisce le strutture algebriche necessarie alla sua risoluzione;
			\item[\texttt{solve}:] risolve il problema parabolico per ogni istante di tempo.
		\end{description}\pause
		Metodi di \emph{post-processing}, che permettono il salvataggio della soluzione a ogni passo temporale e la generazione degli script per la sua visualizzazione grafica.
	\end{block}
}

\frame{
	\frametitle{La classe \texttt{Problem}}
	Ecco lo schema numerico che dobbiamo implementare:
	\[
		\underbrace{\left(\dfrac{\M}{\Delta t} + \vartheta \A \right)}_{\K} \vec{u}^{k+1} = \underbrace{\left(\dfrac{\M}{\Delta t} - (1-\vartheta)\A \right)}_{\textsf{G}} \vec{u}^k + \vec{f}^k
	\]\pause
	Ma ci accorgiamo che
	\[
		\K^{-1}\mathrm{G} = \left[\dfrac{\M}{\Delta t} +\vartheta\A\right]^{-1} \left[\left(\dfrac{\M}{\Delta t}+\vartheta\A\right) - \A \right] = \K^{-1}(\K-\A) = \mathrm{I}-\K^{-1}\A,
	\]\pause
	Dunque
	\[
		\vec{u}^{k+1} = \vec{u}^k + \K^{-1}(\vec{f}^k - \A\vec{u}^k) = \vec{u}^k + \K^{-1}\vec{r}^k
	\]
}

\frame{
	\frametitle{La classe \texttt{Problem}}
	\begin{alertblock}{Il sistema lineare da risolvere è}
		\[
			\K \boldsymbol{\delta}^k = \mathbf{r}^k
		\]
		dove $\mathbf{r}^k$ è il vettore dei residui, e $\boldsymbol{\delta}^k$ rappresenta l'incremento della soluzione, tale per cui
		\[
			\vec{u}^{k+1} = \vec{u}^k + \boldsymbol{\delta}^k
		\]
	\end{alertblock}
}

\frame{
        \frametitle{La classe \texttt{Problem}}
	\begin{block}{Invece, nel caso di forzante non costante}
		si deve risolvere il sistema
		\[
			\K\boldsymbol{\delta}^k = \vec{r}^k + \vartheta(\vec{f}^{k+1}-\vec{f}^k)
		\]
		in cui il termine noto deve essere ricalcolato ad ogni passo.
	\end{block}\pause
	
	\begin{alertblock}{Attenzione!}
		I due casi vengono risolti da diverse versioni dello stesso metodo \texttt{solve} che, tra loro, differiscono solo per la firma.
	\end{alertblock}
}

\frame{
	\frametitle{Il metodo \texttt{initialize}}
	\begin{description}[\texttt{kappaMatrixGen}:]
		\item[\texttt{matrixGen}:] Costruisce la matrice di stiffness.
		\item[\texttt{massMatrixGen}:] Costruisce la matrice di massa.
		\item[\texttt{forceGen}:] Genera il vettore dei termini noti.
		\item[\texttt{patchMatrix}:] Rende la matrice di stiffness consistente con le condizioni Dirichlet.
		\item[\texttt{bcGen}:] Rende consistente il vettore dei termini noti con le condizioni Dirichlet e Neumann.
		\item[\texttt{initGen}:] Costruisce la soluzione al passo iniziale $k=0$.
		\item[\texttt{kappaMatrixGen}:] Costruisce la matrice $\K$, e ne effettua la fattorizzazione LU.
	\end{description}
}

\begin{frame}[fragile]
	\frametitle{Il metodo \texttt{solve}}
	Ecco le due diverse versioni
	\begin{block}{Con forzante costante}
		\begin{c++}
template<class BIL,class F>
void Problem<BIL,F>::solve()
		\end{c++}
	\end{block}
	\begin{block}{Con forzante tempo-dipendente}
                \begin{c++}
template<class BIL,class F>
void Problem<BIL,F>::solve(double const & t)
                \end{c++}
        \end{block}
\end{frame}

\frame{
	\frametitle{I metodi di \emph{postprocessing}}
	\begin{block}{Funzioni che permettono di creare immagini e video}
		\begin{description}[\texttt{printGnuplotScript}:]
			\item[\texttt{printSol}:] crea un file di testo con la soluzione del problema, a tempo fissato, in corrispondenza dei nodi della griglia;
			\item[\texttt{printGnuplotScript}:] crea lo script per generare le immagini attraverso \texttt{gnuplot};
			\item[\texttt{printAviScript}:] crea lo script per generare i video tramite \texttt{gnuplot} e \texttt{MEncoder}.
		\end{description}
	\end{block}
}
